Personal Computer World 2009 February/PCWFEB09.iso/Software/Resources/Chat & Communication/Digsby build 37/digsby_setup.exe/lib/uuid.pyo

Python Compiled Bytecode | 2008-10-13 | 14KB | 477 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.5)

__author__ = 'Ka-Ping Yee <[e-mail]>'
(RESERVED_NCS, RFC_4122, RESERVED_MICROSOFT, RESERVED_FUTURE) = [
    'reserved for NCS compatibility',
    'specified in RFC 4122',
    'reserved for Microsoft compatibility',
    'reserved for future definition']

class UUID(object):

    def __init__(self, hex = None, bytes = None, bytes_le = None, fields = None, int = None, version = None):
        if [
            hex,
            bytes,
            bytes_le,
            fields,
            int].count(None) != 4:
            raise TypeError('need one of hex, bytes, bytes_le, fields, or int')

        if hex is not None:
            hex = hex.replace('urn:', '').replace('uuid:', '')
            hex = hex.strip('{}').replace('-', '')
            if len(hex) != 32:
                raise ValueError('badly formed hexadecimal UUID string')

            int = long(hex, 16)

        if bytes_le is not None:
            if len(bytes_le) != 16:
                raise ValueError('bytes_le is not a 16-char string')

            bytes = bytes_le[3] + bytes_le[2] + bytes_le[1] + bytes_le[0] + bytes_le[5] + bytes_le[4] + bytes_le[7] + bytes_le[6] + bytes_le[8:]

        if bytes is not None:
            if len(bytes) != 16:
                raise ValueError('bytes is not a 16-char string')

            int = long('%02x' * 16 % tuple(map(ord, bytes)), 16)

        if fields is not None:
            if len(fields) != 6:
                raise ValueError('fields is not a 6-tuple')

            (time_low, time_mid, time_hi_version, clock_seq_hi_variant, clock_seq_low, node) = fields
            if time_low <= time_low:
                pass
            elif not time_low < 0x100000000L:
                raise ValueError('field 1 out of range (need a 32-bit value)')

            if time_mid <= time_mid:
                pass
            elif not time_mid < 0x10000L:
                raise ValueError('field 2 out of range (need a 16-bit value)')

            if time_hi_version <= time_hi_version:
                pass
            elif not time_hi_version < 0x10000L:
                raise ValueError('field 3 out of range (need a 16-bit value)')

            if clock_seq_hi_variant <= clock_seq_hi_variant:
                pass
            elif not clock_seq_hi_variant < 0x100L:
                raise ValueError('field 4 out of range (need an 8-bit value)')

            if clock_seq_low <= clock_seq_low:
                pass
            elif not clock_seq_low < 0x100L:
                raise ValueError('field 5 out of range (need an 8-bit value)')

            if node <= node:
                pass
            elif not node < 0x1000000000000L:
                raise ValueError('field 6 out of range (need a 48-bit value)')

            clock_seq = clock_seq_hi_variant << 0x8L | clock_seq_low
            int = time_low << 0x60L | time_mid << 0x50L | time_hi_version << 0x40L | clock_seq << 0x30L | node

        if int is not None:
            if int <= int:
                pass
            elif not int < 0x100000000000000000000000000000000L:
                raise ValueError('int is out of range (need a 128-bit value)')


        if version is not None:
            if version <= version:
                pass
            elif not version <= 5:
                raise ValueError('illegal version number')

            int &= -0xC000000000000001L
            int |= 0x8000000000000000L
            int &= -0xF0000000000000000001L
            int |= version << 0x4CL

        self.__dict__['int'] = int


    def __cmp__(self, other):
        if isinstance(other, UUID):
            return cmp(self.int, other.int)

        return NotImplemented


    def __hash__(self):
        return hash(self.int)


    def __int__(self):
        return self.int


    def __repr__(self):
        return 'UUID(%r)' % str(self)


    def __setattr__(self, name, value):
        raise TypeError('UUID objects are immutable')


    def __str__(self):
        hex = '%032x' % self.int
        return '%s-%s-%s-%s-%s' % (hex[:8], hex[8:12], hex[12:16], hex[16:20], hex[20:])


    def get_bytes(self):
        bytes = ''
        for shift in range(0, 128, 8):
            bytes = chr(self.int >> shift & 255) + bytes

        return bytes

    bytes = property(get_bytes)

    def get_bytes_le(self):
        bytes = self.bytes
        return bytes[3] + bytes[2] + bytes[1] + bytes[0] + bytes[5] + bytes[4] + bytes[7] + bytes[6] + bytes[8:]

    bytes_le = property(get_bytes_le)

    def get_fields(self):
        return (self.time_low, self.time_mid, self.time_hi_version, self.clock_seq_hi_variant, self.clock_seq_low, self.node)

    fields = property(get_fields)

    def get_time_low(self):
        return self.int >> 0x60L

    time_low = property(get_time_low)

    def get_time_mid(self):
        return self.int >> 0x50L & 65535

    time_mid = property(get_time_mid)

    def get_time_hi_version(self):
        return self.int >> 0x40L & 65535

    time_hi_version = property(get_time_hi_version)

    def get_clock_seq_hi_variant(self):
        return self.int >> 0x38L & 255

    clock_seq_hi_variant = property(get_clock_seq_hi_variant)

    def get_clock_seq_low(self):
        return self.int >> 0x30L & 255

    clock_seq_low = property(get_clock_seq_low)

    def get_time(self):
        return (self.time_hi_version & 0xFFFL) << 0x30L | self.time_mid << 0x20L | self.time_low

    time = property(get_time)

    def get_clock_seq(self):
        return (self.clock_seq_hi_variant & 0x3FL) << 0x8L | self.clock_seq_low

    clock_seq = property(get_clock_seq)

    def get_node(self):
        return self.int & 0xFFFFFFFFFFFFL

    node = property(get_node)

    def get_hex(self):
        return '%032x' % self.int

    hex = property(get_hex)

    def get_urn(self):
        return 'urn:uuid:' + str(self)

    urn = property(get_urn)

    def get_variant(self):
        if not self.int & 0x8000000000000000L:
            return RESERVED_NCS
        elif not self.int & 0x4000000000000000L:
            return RFC_4122
        elif not self.int & 0x2000000000000000L:
            return RESERVED_MICROSOFT
        else:
            return RESERVED_FUTURE

    variant = property(get_variant)

    def get_version(self):
        if self.variant == RFC_4122:
            return int(self.int >> 0x4CL & 15)


    version = property(get_version)


def _find_mac(command, args, hw_identifiers, get_index):
    import os as os
    for dir in [
        '',
        '/sbin/',
        '/usr/sbin']:
        executable = os.path.join(dir, command)
        if not os.path.exists(executable):
            continue


        try:
            cmd = 'LC_ALL=C %s %s 2>/dev/null' % (executable, args)
            pipe = os.popen(cmd)
        except IOError:
            continue

        for line in pipe:
            words = line.lower().split()
            for i in range(len(words)):
                if words[i] in hw_identifiers:
                    return int(words[get_index(i)].replace(':', ''), 16)
                    continue





def _ifconfig_getnode():
    for args in ('', '-a', '-av'):
        mac = _find_mac('ifconfig', args, [
            'hwaddr',
            'ether'], (lambda i: i + 1))
        if mac:
            return mac
            continue

    import socket as socket
    ip_addr = socket.gethostbyname(socket.gethostname())
    mac = _find_mac('arp', '-an', [
        ip_addr], (lambda i: -1))
    if mac:
        return mac

    mac = _find_mac('lanscan', '-ai', [
        'lan0'], (lambda i: 0))
    if mac:
        return mac



def _ipconfig_getnode():
    import os
    import re as re
    dirs = [
        '',
        'c:\\windows\\system32',
        'c:\\winnt\\system32']

    try:
        import ctypes as ctypes
        buffer = ctypes.create_string_buffer(300)
        ctypes.windll.kernel32.GetSystemDirectoryA(buffer, 300)
        dirs.insert(0, buffer.value.decode('mbcs'))
    except:
        pass

    for dir in dirs:

        try:
            pipe = os.popen(os.path.join(dir, 'ipconfig') + ' /all')
        except IOError:
            continue

        for line in pipe:
            value = line.split(':')[-1].strip().lower()
            if re.match('([0-9a-f][0-9a-f]-){5}[0-9a-f][0-9a-f]', value):
                return int(value.replace('-', ''), 16)
                continue




def _netbios_getnode():
    import win32wnet as win32wnet
    import netbios as netbios
    ncb = netbios.NCB()
    ncb.Command = netbios.NCBENUM
    ncb.Buffer = adapters = netbios.LANA_ENUM()
    adapters._pack()
    if win32wnet.Netbios(ncb) != 0:
        return None

    adapters._unpack()
    for i in range(adapters.length):
        ncb.Reset()
        ncb.Command = netbios.NCBRESET
        ncb.Lana_num = ord(adapters.lana[i])
        if win32wnet.Netbios(ncb) != 0:
            continue

        ncb.Reset()
        ncb.Command = netbios.NCBASTAT
        ncb.Lana_num = ord(adapters.lana[i])
        ncb.Callname = '*'.ljust(16)
        ncb.Buffer = status = netbios.ADAPTER_STATUS()
        if win32wnet.Netbios(ncb) != 0:
            continue

        status._unpack()
        bytes = map(ord, status.adapter_address)
        return (bytes[0] << 0x28L) + (bytes[1] << 0x20L) + (bytes[2] << 0x18L) + (bytes[3] << 0x10L) + (bytes[4] << 0x8L) + bytes[5]


_uuid_generate_random = None
_uuid_generate_time = None
_UuidCreate = None

try:
    import ctypes
    import ctypes.util as ctypes
    _buffer = ctypes.create_string_buffer(16)
    for libname in [
        'uuid',
        'c']:

        try:
            lib = ctypes.CDLL(ctypes.util.find_library(libname))
        except:
            continue

        if hasattr(lib, 'uuid_generate_random'):
            _uuid_generate_random = lib.uuid_generate_random

        if hasattr(lib, 'uuid_generate_time'):
            _uuid_generate_time = lib.uuid_generate_time
            continue


    try:
        lib = ctypes.windll.rpcrt4
    except:
        lib = None

    _UuidCreate = getattr(lib, 'UuidCreateSequential', getattr(lib, 'UuidCreate', None))
except:
    pass


def _unixdll_getnode():
    _uuid_generate_time(_buffer)
    return UUID(bytes = _buffer.raw).node


def _windll_getnode():
    if _UuidCreate(_buffer) == 0:
        return UUID(bytes = _buffer.raw).node



def _random_getnode():
    import random as random
    return random.randrange(0, 0x1000000000000L) | 0x10000000000L

_node = None

def getnode():
    global _node
    if _node is not None:
        return _node

    import sys as sys
    if sys.platform == 'win32':
        getters = [
            _windll_getnode,
            _netbios_getnode,
            _ipconfig_getnode]
    else:
        getters = [
            _unixdll_getnode,
            _ifconfig_getnode]
    for getter in getters + [
        _random_getnode]:

        try:
            _node = getter()
        except:
            continue

        if _node is not None:
            return _node
            continue


_last_timestamp = None

def uuid1(node = None, clock_seq = None):
    global _last_timestamp
    if _uuid_generate_time:
        if clock_seq is clock_seq:
            pass
        elif clock_seq is None:
            _uuid_generate_time(_buffer)
            return UUID(bytes = _buffer.raw)

    import time
    nanoseconds = int(time.time() * 1e+09)
    timestamp = int(nanoseconds / 100) + 0x1B21DD213814000L
    if timestamp <= _last_timestamp:
        timestamp = _last_timestamp + 1

    _last_timestamp = timestamp
    if clock_seq is None:
        import random
        clock_seq = random.randrange(0x4000L)

    time_low = timestamp & 0xFFFFFFFFL
    time_mid = timestamp >> 0x20L & 0xFFFFL
    time_hi_version = timestamp >> 0x30L & 0xFFFL
    clock_seq_low = clock_seq & 0xFFL
    clock_seq_hi_variant = clock_seq >> 0x8L & 0x3FL
    if node is None:
        node = getnode()

    return UUID(fields = (time_low, time_mid, time_hi_version, clock_seq_hi_variant, clock_seq_low, node), version = 1)


def uuid3(namespace, name):
    import md5 as md5
    hash = md5.md5(namespace.bytes + name).digest()
    return UUID(bytes = hash[:16], version = 3)


def uuid4():
    if _uuid_generate_random:
        _uuid_generate_random(_buffer)
        return UUID(bytes = _buffer.raw)


    try:
        import os
        return UUID(bytes = os.urandom(16), version = 4)
    except:
        import random
        bytes = [ chr(random.randrange(256)) for i in range(16) ]
        return UUID(bytes = bytes, version = 4)



def uuid5(namespace, name):
    import sha as sha
    hash = sha.sha(namespace.bytes + name).digest()
    return UUID(bytes = hash[:16], version = 5)

NAMESPACE_DNS = UUID('6ba7b810-9dad-11d1-80b4-00c04fd430c8')
NAMESPACE_URL = UUID('6ba7b811-9dad-11d1-80b4-00c04fd430c8')
NAMESPACE_OID = UUID('6ba7b812-9dad-11d1-80b4-00c04fd430c8')
NAMESPACE_X500 = UUID('6ba7b814-9dad-11d1-80b4-00c04fd430c8')